package hr_project.hr.web;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import hr_project.hr.biz.Emp.IEmpBiz;
import hr_project.hr.biz.Right.IRightBiz;
import hr_project.hr.biz.role.IRoleBiz;
import hr_project.hr.entity.Emp;
import hr_project.hr.entity.Right;
import hr_project.hr.entity.Role;
import hr_project.hr.entity.Role_Right;

@Controller
@RequestMapping("/role")
public class RoleAction {

	@Autowired
	private IRoleBiz biz;
	@Autowired
	private IEmpBiz ebiz;
	@Autowired
	private IRightBiz rbiz;
	
	

	
	public IRightBiz getRbiz() {
		return rbiz;
	}

	public void setRbiz(IRightBiz rbiz) {
		this.rbiz = rbiz;
	}

	public IEmpBiz getEbiz() {
		return ebiz;
	}

	public void setEbiz(IEmpBiz ebiz) {
		this.ebiz = ebiz;
	}

	public IRoleBiz getBiz() {
		return biz;
	}

	public void setBiz(IRoleBiz biz) {
		this.biz = biz;
	}
	
	@RequestMapping("/listRight")
	@ResponseBody
	public List<Right> getRightByemp(HttpSession sess){
		
		Emp emp=(Emp)sess.getAttribute("loger");
		Role rr=biz.getRoleByid(emp.getRo_id().getRo_id());
		return rr.getList();
	}
	
	@RequestMapping("/add")
	public String addRole(String ids,String ro_name){
		System.out.println(ids);
		String arr[]=ids.split(",");
		Role rr=new Role();
		rr.setRo_name(ro_name);
		List<Right> list=new ArrayList<Right>();
		for(String id:arr){
			Right rig=new Right();
			rig.setRi_id(Long.parseLong(id));
			list.add(rig);
		}
		rr.setList(list);
		biz.addRole(rr);
		return "Role-list";
	}
	
	@RequestMapping("/list")
	@ResponseBody
	public List<Role> list(){
		return biz.getAllRole();
		
	}
	
	@RequestMapping("/del")
	public String delRole(long ro_id){
		biz.delRole(ro_id);
		return "Role-list";
	}
	
	@RequestMapping("/deloneRight")
	@ResponseBody
	public void deloneRight(long ro_id,long ri_id,HttpServletResponse res){
		Role_Right rr=new Role_Right();
		rr.setRo_id(ro_id);
		rr.setRi_id(ri_id);
		biz.deloneRight(rr);
		
		try {
			res.getWriter().print("ok");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
	//根据角色id查看角色的权限
	@RequestMapping("/getByid")
	public ModelAndView getByid(Long id){
		System.out.println(id);
		ModelAndView mv=new ModelAndView();
		Role rr=biz.getRoleByid(id);
		mv.addObject("rr", rr);
		mv.setViewName("show_Role");
		return mv;
	}
	
	//根据角色id查找他的权限
	@RequestMapping("/getRightByrid")
	@ResponseBody
	public List<Right> getRightByrid(ModelAndView mv,long id){
		return biz.getRoleByid(id).getList();
	}
	
	//增加时显示已经存在的权限
	@RequestMapping("/showRight")
	@ResponseBody
	public List<Right> showRight(long id){
		System.out.println("进来啦id"+id);
		//所有树的权限
		List<Right> list=rbiz.getParentRight();
		//这个角色所拥有的权限
		List<Right> rlist=biz.getRoleByid(id).getList();
		//循环所有树的权限，并且判断这个权限在角色树中是否存在
		for(Right rr:list){
			//判断之前要在实体类对象中重写 equals方法用来两个对象的比较
			if(rlist.contains(rr)){
				/*//如果存在就将所有树的这个权限的checked值变为true
				rr.setChecked(true);*/
				//由于现在判断的都是其父权限还要与其角色树中的子权限进行比较，所以要将这个权限在角色树中找出这个权限对象
				//先找到其在角色树中集合的角标，根据角标获得对象
				Right rr1=rlist.get(rlist.indexOf(rr));
				//判断rr是否是父亲节点，是就递归不是就选中
				if(rr.getChildren()==null||rr.getChildren().size()<=0){
					rr.setChecked(true);
				}
				/**
				 * 由于要判断其子权限，子权限又有子权限，所以使用了一个递归的方法进行判断
				 * 将角色树的权限对象和所有树的权限对象都传进递归的方法中，
				 * 判断各自是否有子，有子再次进行递归，没有则结束递归
				 * */
				else{
					ifexist(rr,rr1);
				}
			}
		}
		
		return list;
	}
	
	/********递归方法**********/
	public void ifexist(Right rr,Right rr1){
		//先判断各自是否有子有子再次进行递归，没有则结束递归
				//所有树的权限
				List<Right> list=rr.getChildren();
				//这个角色所拥有的权限
				List<Right> rlist=rr1.getChildren();
				//没有则结束递归
				if(list==null||list.size()<=0)return;
				if(rlist==null||rlist.size()<=0)return;
				//有子再次进行判断递归
				for(Right rrx:list){
					//判断之前要在实体类对象中重写 equals方法用来两个对象的比较
					if(rlist.contains(rrx)){
						/*//如果存在就将所有树的这个权限的checked值变为true
						rrx.setChecked(true);*/
						//由于现在判断的都是其父权限还要与其角色树中的子权限进行比较，所以要将这个权限在角色树中找出这个权限对象
						//先找到其在角色树中集合的角标，根据角标获得对象
						Right rrx1=rlist.get(rlist.indexOf(rrx));
						//判断rr是否是父亲节点，是就递归不是就选中
						if(rrx.getChildren()==null||rrx.getChildren().size()<=0){
							rrx.setChecked(true);
						}
						/**
						 * 由于要判断其子权限，子权限又有子权限，所以使用了一个递归的方法进行判断
						 * 将角色树的权限对象和所有树的权限对象都传进递归的方法中，
						 * 判断各自是否有子，有子再次进行递归，没有则结束递归
						 * */
						else{
							ifexist(rrx,rrx1);
						}
					}
				}
	}
	//给单个角色添加权限还要过滤掉已经存在的
	@RequestMapping("/addRoleRight")
	@ResponseBody
	public void addRoleRight(@Param("ids")String ids,@Param("ro_id")long ro_id,HttpServletResponse res){
		
		//根据角色id把关系表的关于这个角色的权限都删除
		biz.delRoleRight(ro_id);
		String[] arr=ids.split(",");
		for(String id:arr){
			System.out.println("增加的"+id);
			Role_Right rr=new Role_Right();
			rr.setRo_id(ro_id);
			long ri_id=Long.parseLong(id);
			rr.setRi_id(ri_id);
			
			biz.addright(rr);
		}
		try {
			res.getWriter().print("ok");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
